package com.example.fpe_vote.utils;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.example.fpe_vote.vo.response.ResponseVoteResultVo;

import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 *@description:   处理string的一些方法
 *@author:        zhoubeibei
 *@email:         2315544970@qq.com
 *@date:          2020/2/7
 *@time:          15:32
 */
public class MyStringUtil {

    public static Integer returnNumber(String str){
        StringBuffer number = new StringBuffer();
        char[] strArr = str.toCharArray();
        for (char string : strArr) {
            // 判断是否为数字
            if ((string+"").matches("[0-9]")){
                number.append(string);
            }
        }
        return Integer.parseInt(number.toString());
    }

    public static String returnUnit(String str){
        StringBuffer characters = new StringBuffer();
        char[] strArr = str.toCharArray();
        for (char string : strArr) {
            // 判断是否为汉字
            if (isChineseChar(string+"")){
                characters.append(string);
            }
            // 判断是否为字母
            if ((string+"").matches("[a-z]") || (string+"").matches("[A-Z]")){
                characters.append(string);
            }
        }
        return characters.toString();
    }

    public static int[] toInt(String S){
        //逗号分割的数据
        StringTokenizer tokenizer=new StringTokenizer(S,",");
        String[] result=new String[tokenizer.countTokens()];
        int i=0;int k=0;int m=0;
        int[] intArr = new int[S.length()*2];
        while (tokenizer.hasMoreTokens()){
            result[i++]=tokenizer.nextToken();
        }
        //得到数字
        for(int j=0;j<result.length;j++){
            intArr[j]= Integer.parseInt(result[j]);
        }
        //intArr有无效长度
        //k用于判断intArr有效长度
        for(int l:intArr){
            if(l!=0){
                k++;
            }else
                m++;
            //当超过有效长度，弹出循环
            if(m>=2)
                break;
        }
        //定义一个结果数组，长度和intArr有效长度一样
        int[] resultArr=new int[k];
        //往resultArr赋值
        for(int l=0;l<=intArr.length;l++) {
            if (intArr[l] != 0) {
                resultArr[l] = intArr[l];
            }
            //超过有效长度弹出循环
            if (l >= k) {
                break;
            }
        }
        //返回结果
        return resultArr;
    }

    private static boolean isChineseChar(String str){
        boolean temp = false;
        Pattern p= Pattern.compile("[\u4e00-\u9fa5]");
        Matcher m=p.matcher(str);
        if(m.find()){
            temp =  true;
        }
        return temp;
    }

    //字符串拼接方法
    public static String intToString(int id, String s){
        if(StringUtils.isBlank(s)|| Objects.equals(s, "0")|| Objects.equals(s, "无")){
            return String.valueOf(id);
        }else {
            String s1=","+id;
            return s+s1;
        }
    }
    //字符串拼接方法
    public static String strToString(String s1, String s2){
        if(Objects.equals(s2, "") ||StringUtils.isBlank(s2)|| Objects.equals(s2, "0")|| Objects.equals(s2, "无")){
            return s1;
        }else {
            String res=";"+s1;
            return s2+res;
        }
    }
    //文件名
    public static String strToStringOfFileName(String s1, String s2){
        if(Objects.equals(s2, "") ||StringUtils.isBlank(s2)|| Objects.equals(s2, "0")|| Objects.equals(s2, "无")){
            return s1;
        }else {
            String res="&"+s1;
            return s2+res;
        }
    }

    //字符串拼接方法---数组版
    public static String strToString(String[] s){
        if(s.length==0){
            return null;
        }else{
            String result=org.apache.commons.lang3.StringUtils.join(s,";");
            return result;
        }
    }

    //编号生成方法
    public static String sequenceCode(Integer count, Integer maxNum) {
        //获取当前时间
        SimpleDateFormat sdf = new SimpleDateFormat("MMdd");
        String dateNow = sdf.format(new Date());
        if(maxNum<1000){
            maxNum=1000;
        }else if(1000<maxNum&&maxNum<10000){
            maxNum=10000;
        }else
            maxNum=100000;
        String strNum = String.valueOf(maxNum + count);
        return dateNow+strNum.substring(1);
    }

    /**
     * 返回中文的首字母
     *
     * @param str
     * @return
     */
//    public static String getPinYinHeadChar(String str) {
//        String convert = "";
//        for (int j = 0; j < str.length(); j++) {
//            char word = str.charAt(j);
//            String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(word);
//            if (pinyinArray != null) {
//                convert += pinyinArray[0].charAt(0);
//            } else {
//                convert += word;
//            }
//        }
//        return convert.toUpperCase();
//    }

    /**
     * @param length 字符串长度
     * @param size 字符数组个数
     * @return 一个字符串数组
     */
    public static String[] getRandomStringArray(int length, int size){
        String[] strs = new String[size];
        char[] chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".toCharArray();
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        HashSet<String> set = new HashSet<>();
        while (set.size() < size){//生成随机字符串到set里面
            sb.setLength(0);
            for (int i = 0; i < length; i++)
                sb.append(chars[random.nextInt(62)]);
            set.add(sb.toString());
        }
        int i= 0;
        for (String s : set)//将set里面的数据存放到数组
            strs[i++] = s;
        return strs;
    }

    /**
     * 获取字符串长度（按字节）
     * @param s
     * @return
     */
    public static int getStringLength(String s){
        int length = 0;
        for(int i = 0; i < s.length(); i++)
        {
            int ascii = Character.codePointAt(s, i);
            if(ascii >= 0 && ascii <=255)
                length++;
            else
                length += 2;
        }
        return length;
    }

    /**
     * 统计有几份
     * @param s 统计对象
     * @param amount 按amount来统计
     * @return
     */
    public static int getLength(String s, int amount){
        int Length=getStringLength(s);
        int result= (int) Math.ceil((double)Length/amount);
        return result;
    }

    /**
     * 按份数分割字符串
     * @param string 分割对象
     * @param n 预计分割份数
     * @param amount 每份数量
     * @return
     */
    public static String[] divide(String string, int n, int amount)
    {
        String[] strings=string2Array(string);
        String[] result=new String[n];
        for(int i=0;i<n;i++){
            String[] divides=interception(strings,amount);
            result[i]=divides[0];
            if(getStringLength(divides[1])>amount){
                strings=string2Array(divides[1]);
            }else{
                result[i+1]=divides[1];
                break;
            }
        }
        return result;
    }
    /**
     * 将字符串转成字符串数组
     * @param string 转化对象
     * @return
     */
    public static String[] string2Array(String string)
    {
        String[] temp = new String[string.length()];
        for (int i = 0; i < temp.length; i++) {
            temp[i] = string.substring(i,i+1);
        }
        return temp;
    }

    /**
     * 字符串按字节数截取
     * @param str 截取对象
     * @param n 截取位数
     */
    public static String[] interception(String[] str, int n)
    {
        int count = 0;
        String m = "[\u4e00-\u9fa5]";
        //定义一个分割好的数组，用于返回
        String[] result=new String[2];
        String one="";
        String two="";
        for(int i=0;i<str.length;i++){
            //计数器计数
            if(count<n){
                one=one+str[i];
                if (str[i].matches(m)) {
                    //如果当前字符是汉字，计数器加2
                    count += 2;
                }else {
                    count+=1;
                }
            }else {
                two=two+str[i];
                if (str[i].matches(m)) {
                    //如果当前字符是汉字，计数器加2
                    count += 2;
                }else {
                    count+=1;
                }
            }
        }
        result[0]=one;
        result[1]=two;
        return result;
    }

    /**
     * 工单号 按范围取值并返回
     * @param orderNumMin 起始
     * @param orderNumMax 结尾
     * @return
     */
    public static String[] findOrders(String orderNumMin, String orderNumMax){
        int min= Integer.parseInt(orderNumMin.substring(7));
        int max= Integer.parseInt(orderNumMax.substring(7));
        String header=orderNumMin.replace(String.valueOf(min),"");
        String[] result=new String[max-min+1];
        for(int i=0;i<result.length;i++){
            int end=min+i;
            result[i]=header+end;
        }
        return result;
    }

    /**
     * 数组合并方法
     * @param a
     * @param b
     * @return
     */
    public static String[] concat(String[] a, String[] b) {
        String[] c= new String[a.length+b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);
        return c;
    }

    public static Map<String, Long> frequencyOfListQ(List<String> falcons){
        if(CollectionUtils.isEmpty(falcons)){
            return new HashMap<>();
        }
        return falcons.stream().collect(Collectors.groupingBy(k->k, Collectors.counting()));
    }


    public static ResponseVoteResultVo BubbleSort2(Long[] A, String[] names){
        for (int j = 0; j < A.length-1; j++) {//外层循环遍历数组
            for (int i = 0; i < A.length-1-j;i++) {//里层循环遍历数组控制次数。
                if (A[i]>A[i+1]) {//判断本元素是否比下一个元素大，如果大，则交换位置
                    long temp=A[i];
                    A[i] = A[i+1];
                    A[i+1]=temp;
                    //名字也改变
                    String name=names[i];
                    names[i] = names[i+1];
                    names[i+1]=name;
                }
            }
        }
        ResponseVoteResultVo vo=new ResponseVoteResultVo();
        vo.setNames(names);
        vo.setCounts(A);
        return vo;
    }

}
